#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>

using namespace std;

#define COMMAND_SIZE 1024
#define FORMAT "[%s@%s:%s]#"

//shell的全局数据
//argc是外部输入的参数个数，argv[ ]是参数的字符串数组
#define MAX_ARGC 128
char* g_argv[MAX_ARGC];//命令行参数表
int g_argc;

//环境变量表
#define MAX_ENV 100
char* g_env[MAX_ENV];//环境变量表是一个指针数组
int g_envs;

//退出码
int lastcode;

//for test
char n_pwdenv[2024];
char n_pwd[1024];

//重定向数据
#define NONE_REDIR 0
#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3

int redir = NONE_REDIR;
string filename;

//初始化环境变量表
void InitEnv()
{
    //从父进程那里获取环境变量表
    //libc中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时，要进行extern声明。
    extern char** environ;
    memset(g_env,0,sizeof(g_env));
    g_envs = 0;

    for(int i = 0;environ[i];i++)
    {
        //申请空间
        g_env[i] = (char*)malloc(strlen(environ[i]) + 1);
        //拷贝
        strcpy(g_env[i],environ[i]);
        g_envs++;
    }
    //环境变量表是一个指针数组，每一个位置存放着地址数据，基本上指向一个个字符串，最后必须以NULL结尾。
    g_env[g_envs] = NULL;
    //导成环境变量表
    for(int i = 0;g_env[i];i++)
    {
        putenv(g_env[i]);
    }
    environ = g_env;
}


const char *GetUserName ()
{
    const char* name = getenv("USER");
    return name == NULL ? "None" : name;
}
char* GetHostName ()
{
    //在Unbuntu中没有 "HOSTNAME" 环境变量
    // const char* hostname = getenv("HOSTNAME");
    //return hostname == NULL ? "None" : hostname;
    char* hostname = (char*)malloc(255);
    if(gethostname(hostname,sizeof(hostname)) == 0)
        return hostname;
    else
    {
        // cout<<"无法获得主机名"<<endl;
        return NULL;
    }
}
const char* GetPwd ()
{
    //const char* pwd = getenv("PWD");
    //使用cd等命令时，进程的路径先改变，然后再更新环境变量
    //所以如果通过在环境变量表里查找路径，是不能够及时更新的
    //使用系统接口getcwd(),getcwd()会将当前工作目录的绝对路径复制到参数buffer所指的内存空间中,参数size为buf的空间大小
    const char* pwd = getcwd(n_pwd,sizeof(n_pwd));
    //更新环境变量
    if(pwd != NULL)
    {
        snprintf(n_pwdenv,sizeof(n_pwdenv),"PWD=%s",n_pwd);
        //putenv 函数用来向环境表中 添加或者修改 环境变量
        //环境变量必须以 "name=value" 的形式给出
        //如果环境表中没有 name 这个环境变量，则添加该环境变量；
        //如果环境表中已经有了name这个环境变量，则先删除之前的 value，再修改为新的 value。
        putenv(n_pwdenv);
    }
    return pwd == NULL ? "None" : pwd;
}
const char* GetHome()
{
    const char* home = getenv("HOME");
    return home == NULL ? "":home;//"None"不能转成string，空串可以
}

//获取当前目录
string DirName(const char* pwd)
{
#define SLASH "/" //目录分隔符
    string dir = pwd;
    if(dir == SLASH)//当前是根目录
        return SLASH;
    auto pos = dir.rfind(SLASH);
    if(pos == string::npos)
        return "BUG";
    
    return dir.substr(pos + 1);
}

//制作命令行提示符，并将其格式化
void MakeCommandLine(char* cmd_prompt,int size)
{
    //获取用户名，主机名，当前路径，并以标准格式存入数组
    //user1@hcss-ecs-a594:~/Linux/linux/myshell$
    snprintf(cmd_prompt,size,FORMAT,GetUserName(),GetHostName(),DirName(GetPwd()).c_str());
    // snprintf(cmd_prompt, size, FORMAT, GetUserName(), GetHostName(), GetPwd());
}
//打印命令行提示符
void PrintCmdPrompt()
{
    char cmd_prompt[COMMAND_SIZE];
    MakeCommandLine(cmd_prompt,sizeof(cmd_prompt));
    printf("%s",cmd_prompt);
    fflush(stdout);//刷新缓冲区
}
//获取命令行参数
bool GetCommandLine(char commandline[],int size)
{
    //ls -a -l -> "ls -a -l"
    char* c = fgets(commandline,size,stdin);//读取命令行
    if(c == NULL)
        return false;
    //在输入命令行参数时，会打一个\n，所以要清理掉这个\n
    //ls -a -l -> "ls -a -l\n"
    commandline[strlen(commandline) - 1] = 0;//strlen用于计算字符串的长度，不包括 \0，sizeof包括 
    //如果用户什么都没输入（即只有一个\n）
    if(strlen(commandline) == 0)
        return false;

    return true;
}
//命令行参数分析
bool CmdPromptParse(char commandline[])
{
    //"ls -a -l"->"ls""-a""-l"
#define SEP " " // 分隔符
    //清理之前的数据
    g_argc = 0;
    g_argv[g_argc++] = strtok(commandline,SEP);//切割字符串
    //继续切割原字符串
    while(g_argv[g_argc++] = strtok(nullptr,SEP))
        ;
    g_argc--;//上面的循环中，g_argc会多加一次
    return g_argc > 0 ? true : false;
}
//调试
void PrintArgv()
{
    for(int i = 0;i < g_argc;i++)
    {
        printf("argv[%d]->%s\n",i,g_argv[i]);
    }
    printf("%d\n",g_argc);
}

//处理cd命令
void Cd()
{
    //cd
    if(g_argc == 1)
    {
        string home = GetHome();
        if(home.empty())
            return;
        //改变路径
        chdir(home.c_str());
    }
    else
    {
        string where = g_argv[1];
        chdir(where.c_str());
    }
}
//处理echo命令
void Echo()
{
    //echo 后面一定要有参数
    if(g_argc == 2)
    {
        //获取后面的参数
        string opt = g_argv[1];
        //实现不同功能
        //1.echo $? 打印最近一个进程的退出码
        if(opt == "$?")
        {
            cout<<lastcode<<endl;
            lastcode = 0;//echo进程的退出码为0
        }
        else if(opt[0] == '$')//echo+$+环境变量：查看环境变量的内容
        {
            //提取环境变量的名字
            string name = opt.substr(1);
            const char* env_value = getenv(name.c_str());
            if(env_value)
                cout<<env_value<<endl;
        }
        else 
        {
            cout<<opt<<endl;
        }
            
    }
}

//处理内键命令
bool CheckAndExecBuiltin()
{
    string cmd = g_argv[0];
    if(cmd == "cd")
    {
        //执行cd命令
        Cd();
        return true;
    }
    else if(cmd == "echo")
    {
        Echo();
        return true;
    }

    return false;
}

//清除空格
void TrimSpace(char cmd[],int &end)
{
    while(isspace(cmd[end]))
    {
        end++;
    }
}

//重定向分析
void RedirCheck(char cmd[])
{
    //清除数据
    redir = NONE_REDIR;
    filename.clear();
    //分析
    int start = 0;
    int end = strlen(cmd) - 1;
    //找 > < >>
    while(end > start)
    {
        if(cmd[end] == '>')//输出重定向
        {
            if(cmd[end - 1] == '>')//>>
            {
                redir = APPEND_REDIR;
                cmd[end - 1] = 0;
            }
            else
            {
                redir = OUTPUT_REDIR;
            }
                cmd[end++] = 0;//置0
                TrimSpace(cmd,end);//排除空格
                filename = cmd + end;
                break;
        }
        else if(cmd[end] == '<')//输入重定向
        {
            cmd[end++] = 0;
            TrimSpace(cmd,end);
            redir = INPUT_REDIR;
            filename = cmd + end;
            break;
        }
        else
        {
            end--;
        }
    }
}

//执行命令
int Execute()
{
    int status = 0;
    //创建子进程
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        //检查重定向
        if(redir == INPUT_REDIR)
        {
            int fd = open(filename.c_str(), O_RDONLY);
            if(fd < 0)
                exit(1);
            dup2(fd, 0);
            close(fd);
        }
        else if(redir == OUTPUT_REDIR)
        {
            int fd = open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
            if(fd < 0)
                exit(2);
            dup2(fd, 1);
            close(fd);
        }
        else if(redir == APPEND_REDIR)
        {
            int fd = open(filename.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
            if(fd < 0)
                exit(2);
            dup2(fd, 1);
            close(fd);
        }

        execvp(g_argv[0],g_argv);
        exit(1);
    }
    //父进程
    pid_t rid = waitpid(id,&status,0);
    if(rid > 0)//waitpid返回收集到的子进程的进程ID；
    {
        lastcode = WEXITSTATUS(status);//提取子进程退出码
    }

    return 0;

}
//释放环境变量表
void Clean()
{
    for(int i = 0;g_env[i];i++)
    {
        free(g_env[i]);
        g_env[i] = nullptr;
    }
    //free((void*)g_env);
    //g_env = NULL;
}

int main()
{
    //创建自己的环境变量表
    InitEnv();

    while(true)
    {
        //1.输出命令行字符串：用户名@主机名:当前路径$
        PrintCmdPrompt();    

        //2.获取命令行参数
        char commandline[COMMAND_SIZE];
        if(!GetCommandLine(commandline,sizeof(commandline)))
        {
            //重复获取
            continue;
        }
        //3.分析重定向, "ls -a -l > file.txt" -> "ls -a -l" "file.txt" -> 判定重定向方式
        RedirCheck(commandline);

        //4.分析命令行，将字符串拆分，并转化为可执行程序
        if(!CmdPromptParse(commandline))
            continue;//命令行解析失败
        //PrintArgv();
        
        
        //5.检测并处理内键命令，例如cd
        if(CheckAndExecBuiltin())
            continue;//内键命令不需要创建子进程执行

        //6.执行命令
        Execute();

    }
    //释放资源
    Clean();

    return 0;
}
